package persistencia.carreras;


import compartido.IEntidad;


import persistencia.IAlmacen;
import persistencia.IEnsamblador;
import persistencia.IIngrediente;
import persistencia.IProducto;
import persistencia.compartido.ProductoSinValores;
import persistencia.compartido.Tipo;
import persistencia.excepciones.EscritorIncompatible;
import persistencia.excepciones.LectorIncompatible;

public class EnsambladorClaveValor implements IEnsamblador {
	protected static Tipo<IEntidad> tipoAceptado = new Tipo<IEntidad>(ClaveValor.class);
	
	@Override
	public boolean esComptabile(IProducto p) {
		return true;
	}

	@Override
	public boolean esCompatible(IEntidad e) {
		return (e instanceof ClaveValor);
	}
	
	@Override
	public IEntidad leer(IProducto p, IAlmacen almacen) throws LectorIncompatible {
		if (!esComptabile(p))
			throw new LectorIncompatible();
		
		String clave = p.getNombre();		
		String valor = p.obtenerIngrediente("valor").getValor();
		
		ClaveValor cv = new ClaveValor(clave, valor);
		
		return cv;
	}

	@Override
	public IProducto escribir(IEntidad e, IAlmacen almacen) throws EscritorIncompatible {
		if (!esCompatible(e))
			throw new EscritorIncompatible();
		
		ClaveValor cv  = (ClaveValor)e;
		Tipo<IEntidad> tipo = new Tipo<IEntidad>(e.getClass());

		IProducto copia = almacen.crearProducto("clave",cv.getIdentificador(), tipo);
		IIngrediente attr = almacen.crearIngrediente("valor", cv.getValor());
		if (!copia.agregar(attr))
			copia.modificar(attr);
		
		return copia;
	}

	@Override
	public IProducto getDummy(Tipo<IEntidad> tipo) throws EscritorIncompatible {
		if (!tipoAceptado.esSuperTipoDe(tipo))
			throw new EscritorIncompatible();
		
		ProductoSinValores producto = new ProductoSinValores();
		producto.agregarCampo("clave");
		producto.agregarCampo("valor");
		return producto;
	}
}
 